package com.tiancheng.trade.payment.util;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;

import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Stream;

/**
 * @Auther: ld
 * @Date: 2024/2/27 15:57
 * @Param ${tags}
 * @Description:
 */
@Slf4j
public class CommonUtil {

    /**
     * 解析参数
     *
     * @param params
     * @return
     * @throws UnsupportedEncodingException
     */
    public static Map<String, Object> parseParams(String params) {
        String[] paramsArr = params.split("&");
        Map<String, Object> paramsMap = new HashMap<>();
        Stream.of(paramsArr).forEach(param -> {
            String[] keyValue = param.split("=");
            paramsMap.put(keyValue[0], keyValue.length == 2 ? keyValue[1] : "");
//            int inx = param.indexOf("=");
//			String key = param.substring(0, inx);
//			String value = "";
//			if(inx + 1 < param.length()) {
//				value = param.substring(inx+1, param.length());
//			}
//			paramsMap.put(key, value);
        });
        return paramsMap;
    }

    /**
     * 获取随机数
     *
     * @param min
     * @param max
     * @return
     */
    public static int getRandom(int min, int max) {
        Random random = new Random();
        int s = random.nextInt(max) % (max - min + 1) + min;
        return s;
    }

    /**
     * url编码
     *
     * @param str
     * @return
     */
    public static String urlEncode(String str) {
        try {
            return URLEncoder.encode(str, "utf-8");
        } catch (UnsupportedEncodingException e) {
            log.error(e.getMessage(), e);
            return str;
        }
    }

    /**
     * 解码
     *
     * @param str
     * @return
     */
    public static String urlDecode(String str) {
        try {
            return URLDecoder.decode(str, "utf-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            log.error(e.getMessage(), e);
            return str;
        }
    }

    /**
     * 去掉字符串中的空格
     *
     * @param str
     * @return
     */
    public static String trim(String str) {
        if (StringUtils.isEmpty(str)) {
            return str;
        }
        return str.replaceAll(" ", "");
    }

    /**
     * 去掉字符串中的无效字符，防止下单报错
     *
     * @param str
     * @return
     */
    public static String orderNameHandle(String str) {
        String dest = "";
        if (str != null) {
            Pattern p = Pattern.compile("\t|\r|\n");
            Matcher m = p.matcher(str);
            dest = m.replaceAll("").replaceAll("/", "");
            dest = dest.trim();
        }
        String s = symbolHandle(dest);
        if(s.length()>64){
            return s.substring(0,64);
        }
        return s;
    }

    public static String symbolHandle(String str) {
        try {
            String regEx = "[\n`~!@#$%^&*()+=|{}':;',\\[\\].<>/?~！@#￥%……&*()——+|{}‘；\\-【】：”“’。， 、？]";
            // 除了字母数字下划线之外的字符为非法字符
            Pattern pattern = Pattern.compile(regEx);
            // 指定设置非法字符
            Matcher matcher = pattern.matcher(str);
            StringBuffer buffer = new StringBuffer();
            //如果找到非法字符
            while (matcher.find()) {
                // 如果里面包含非法字符如冒号双引号等，那么就把他们消去，并把非法字符前面的字符放到缓冲区
                matcher.appendReplacement(buffer, "");
            }
            // 将剩余的合法部分添加到缓冲区
            matcher.appendTail(buffer);
            return buffer.toString();
        }catch (Exception e){
            return str;
        }
    }

    /**
     * 计算中英文字符串的字节长度 <br/>
     * 一个中文占3个字节
     *
     * @param str
     * @return int 字符串的字节长度
     */
    public static int getStrByteLength(String str) {
        if (str == null || str.length() == 0) {
            return 0;
        }
        return str.getBytes(StandardCharsets.UTF_8).length;
    }

    /**
     * 按照指定长度截取
     *
     * @param str
     * @param max
     * @param length
     * @return
     */
    public static String subStr(String str, int max, int length) {
        if (getStrByteLength(str) >= max) {
            return str.substring(0, length) + "...";
        } else {
            return str;
        }
    }

    /**
     * map切割
     *
     * @param map     被切割map
     * @param maxSize 分割后每个map的最大节点数量
     * @return List
     */
    public static <K, V> List<Map<K, V>> splitMap(Map<K, V> map, int maxSize) {
        // 被切割成的数量
        int num = (map.size() % maxSize) == 0 ? (map.size() / maxSize) : (map.size() / maxSize + 1);
        List<Map<K, V>> list = new ArrayList<>(num);
        if (map.size() <= maxSize) {
            list.add(map);
            return list;
        }
        int initNum = (int) (maxSize / 0.75) + 1;
        Map<K, V> resMap = new HashMap<>(initNum);
        long index = 1;
        for (Map.Entry<K, V> entry : map.entrySet()) {
            resMap.put(entry.getKey(), entry.getValue());
            if (resMap.size() == maxSize || index == map.size()) {
                list.add(resMap);
                if (index < map.size()) {
                    resMap = new HashMap<>(initNum);
                }
            }
            index++;
        }
        return list;
    }

    /**
     * list切割
     *
     * @param list    被切割list
     * @param maxSize 分割后每个list的最大节点数量
     * @return List
     */
    public static <T> List<List<T>> splitList(List<T> list, int maxSize) {
        // 被切割成的数量
        int num = (list.size() % maxSize) == 0 ? (list.size() / maxSize) : (list.size() / maxSize + 1);
        List<List<T>> results = new ArrayList<>(num);
        if (list.size() <= maxSize) {
            results.add(list);
            return results;
        }
        List<T> resList = new ArrayList<>(maxSize);
        long index = 1;
        for (T t : list) {
            resList.add(t);
            if (resList.size() == maxSize || index == list.size()) {
                results.add(resList);
                if (index < list.size()) {
                    resList = new ArrayList<>(maxSize);
                }
            }
            index++;
        }
        return results;
    }

    public static String cent2YuanStr(int cent) {
        return new BigDecimal(cent).divide(new BigDecimal(100), 2,BigDecimal.ROUND_HALF_UP).toString();
    }

    public static String cent2YuanStr(long cent) {
        return new BigDecimal(cent).divide(new BigDecimal(100), 2,BigDecimal.ROUND_HALF_UP).toString();
    }

    public static String cent2YuanStr(double cent) {
        return new BigDecimal(cent).divide(new BigDecimal(100), 2,BigDecimal.ROUND_HALF_UP).toString();
    }

    public static String subString(String str,int max){
        if(StringUtils.isEmpty(str)||str.length()<=max){
            return str;
        }
        return str.substring(0,max);
    }

//    public static void main(String[] args) {
//        Map<String, Object> map = new HashMap<>();
//        map.put("aaa", 124);
//        map.put("asd", 124);
//        map.put("fdg", 124);
//        map.put("fdd", 124);
//        map.put("ert", 124);
//
//        List<Map<String, Object>> list = splitMap(map, 2);
//        System.out.println("list = " + list);
//
//        List<Integer> list1 = new ArrayList<>();
//        list.add(1);
//        list.add(2);
//        list.add(3);
//        list.add(4);
//        list.add(5);
//        list.add(6);
//        list.add(7);
//
//        System.out.println(splitList(list1, 2));
//        System.out.println(cent2YuanStr(1565.4));
//    };

}
